from threading import *
import sys
import socket
from time import time, ctime
import select
import re


conn_client={}

host='localhost'

nbCol=30
nbLignes=30

mySocketReception=None
mySocketEmission=None
thReception=None

port=0

class Client:

     def __init__(self,HOST,PORT):

          self.mySocketReception=socket.socket(socket.AF_INET,socket.SOCK_STREAM)          
          self.mySocketEmission=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
          
          try:
               self.mySocketEmission.connect((HOST,PORT))
               self.mySocketReception.bind((HOST,PORT+1))
               
          except socket.error:
               print "La liaison a echouee"
               sys.exit(-1)
               
          print "Serveur pret"
          
          self.mySocketEmission.send("clientPret")
     
          while 1:
               self.mySocketReception.listen(5)
               
               (conn,add)=self.mySocketReception.accept()
               print "connection entrante : %s:%d" % add
               
               #mySocketEmission.send("clientPret")
               
               thReception=ThreadReception(conn,self)
               thReception.start()
               
               it=thReception.getName()
               conn_client[it]=conn
               #print "Client %s connecte, adresse IP %s, port %s" %(it,add[0],add[1])

          mySocketReception.close()
          mySocketEmission.close()


#Gestion de reception des informations
class ThreadReception(Thread):
     def __init__(self,connexion,parent):
          print "threadReception initialisee"
          Thread.__init__(self)
          self.connexion=connexion
          print "threadReception initialisee 2"
          self.parent=parent
          self.running=True

     def run(self):
          #nom=self.getName()

          while 1:
               msgClient=self.connexion.recv(1024)
               print msgClient
               
               # if msgClient=="serveurPret":
               #      try: 
               #           self.parent.mySocketEmission.connect(('localhost',port+1))
               #      except socket.error:
               #           print "La liaison a echouee"
               #           sys.exit()
               #           self.running=False
                     
               print "Possibilite d'envoi au client"

               self.parent.mySocketEmission.send("test1")
               self.parent.mySocketEmission.send("test2")

               while self.running:    
                    msg = raw_input('>> ')
	# envoi puis reception de la reponse
                    self.parent.mySocketEmission.send(msg)
               
               
               # if msgClient=="nbPartiesEnAttente":
               #      nbPartiesEnAttente=self.connexion.recv(1024)
               #      if re.search(r"^[0-9]+$",nbPartiesEnAttente)!=None:
               #           nbPartiesEnAttente=int(nbPartiesEnAttente)
               #           if self.connexion.recv(1024)=="ListePartiesEnAttente":
               #                #print "liste parties"
               #                partiesEnAttente=self.connexion.recv(1024).split(";")
               #                if len(partiesEnAttente)!=nbPartiesEnAttente:
               #                     self.parent.mySocketEmission.send("Pb_NbPartie_ListePartie")
               #                     print "Probleme nb parties dans la liste different du nb de parties attendu"
               #                else:
               #                     pb=False

               #                     for i in range(nbPartiesEnAttente):
               #                          #print partiesEnAttente[i]
               #                          partiesEnAttente[i]=partiesEnAttente[i].split(",")
               #                          if re.search(r"^[0-9]+$",partiesEnAttente[i][1])==None:
               #                               self.parent.mySocketEmission.send("Pb_ListePartie_nbJoueursAttendus")
               #                               pb=True
               #                               break
               #                          partiesEnAttente[i][1]=int(partiesEnAttente[i][1])

               #                     #traitement pour difficulte
               #                          if re.search(r"^[0-9]+$",partiesEnAttente[i][3])==None:
               #                              parent.mySocketEmission.send("Pb_ListePartie_nbJoueursDejaPresent")  
               #                              pb=True
               #                              break 
               #                          partiesEnAttente[i][3]=int(partiesEnAttente[i][3])

               #                     if not pb:
               #                          print partiesEnAttente
               #                          self.app.affichagePartieDisp(nbPartiesEnAttente,partiesEnAttente)
                                        
               #           #fonction de gestion de l'affichage des parties en cours et des choix
               #           #il faut ensuite conserver toutes les donnees de la partie choisie
               #      else:
               #           self.parent.mySocketEmission.send("Pb_NbPartie")

               # elif msgClient=="listeJoueursFinale":
               #      listeJoueurs=self.connexion.recv(1024).split(",")
               #      self.app.debutPartie(listeJoueurs)
               #      #fonction de gestion de la liste des joueurs
               #      print listeJoueurs

         
               # elif msgClient=="matrice":
               #      matrice=self.connexion.recv(1024).split(";")
               #      if len(matrice)!=nbLignes:
               #           self.parent.mySocketEmission.send("Pb_Matrice_NbLignes")
               #           print "Pb: nb de lignes de matrice different du nb de ligne de la grille"
               #      else:
               #           for i in range(len(matrice)):
               #                matrice[i]=matrice[i].split(",")
               #                if len(matrice[i])!=nbCol:
               #                     self.parent.mySocketEmission.send("Pb_Matrice_NbColonnes")
               #                     print "Pb: nb de colonnes de matrice different du nb de colonnes de la grille"
               #                else:
               #                     pb=False
               #                     for j in range(len(matrice[i])):
               #                          if re.search(r"^[0-9]+$",matrice[i][1])==None:
               #                               self.parent.mySocketEmission.send("Pb_Matrice")
               #                               pb=True
               #                               break
               #                          matrice[i][j]=int(matrice[i][j])

               #                     if not pb:
               #                          print matrice
               #                          print "Conservation de la matrice"
               #                          self.app.Matrice(matrice)
               #      #fonction de gestion et conservation de la matrice avec emplacement des bombes et des numeros
                    
               # elif msgClient=="toi":
               #      print "c'est a ton tour"
               #      self.app.Tour()
               #      #fonction qui joue

               # elif msgClient=="modificationCompteur":
               #      nomJoueurMod=self.connexion.recv(1024)
               #      valeurNewCompteur=self.connexion.recv(1024)
               #      if re.search(r"^[0-9]+$",valeurNewCompteur)==None:
               #           self.parent.mySocketEmission.send("Pb_modifCompteur")
               #           break
               #      else:
               #           valeurNewCompteur=int(self.connexion.recv(1024))
               #           #modification du compteur du Joueur nomJoueurMod
               #           print "modification compteur"
               #           self.app.modifCompteur(nomJoueurMod,valeurNewCompteur)
               #           print nomJoueurMod,valeurNewCompteur

               # elif msgClient=="clic":
               #      click=self.connexion.recv(1024).split(",")
               #      if re.search(r"^[0-9]+$",click[0])==None or re.search(r"^[0-9]+$",click[1])==None:
               #           self.parent.mySocketEmission.send("Pb_click")
               #           break
               #      else:
               #           click[0]=int(click[0])
               #           click[1]=int(click[1])
               #           print click
               #           typ=click[2]
               #           nom=click[3]
               #           self.app.decouvrement(click,typ,nom)
               #      #fonction de decouvrement de la grille

               # elif msgClient=="gagne":
               #      joueurPerdant=self.connexion.recv(1024)
               #      print "Vous avez gagne "+joueurPerdant
               #      self.app.Gagne(joueurPerdant)
               #      #fonction de gestion de la fin

               # elif msgClient=="partiePerdu":
               #      joueurPerdant=self.connexion.recv(1024)
               #      print joueurPerdant+" a perdu mais la partie est pas finie"
               #      self.app.perdantContinu(joueurPerdant)
               #      #fonction de gestion de suppression de joueurPerdant des scores
               
               # elif msgClient=="perdu":
               #      joueurGagnant=self.connexion.recv(1024)
               #      print joueurGagnant+" a gagne et vous avez perdu"
               #      self.app.perdu(joueurGagnant)
               #      #fonction de gestion de la fin
                    



        #Fermeture de la connexion
          self.connexion.close()
          del conn_client[nom]
          print "Client %s deconnecte" %nom
        #Fin du thread

if __name__=="__main__":
     global port
     import sys
     try:
          if len(sys.argv)<2:
               print "usage : %s <port>" % (sys.argv[0],)
               sys.exit(-1)
          port=int(sys.argv[1])
          Client(host,port)
          thReception.join()
     except:
          thReception.running=False
